YES 0.517 H-Termination proof of /home/matraf/haskell/eval_FullyBlown_Fast/FiniteMap.hs
H-Termination of the given Haskell-Program with start terms could successfully be proven:



HASKELL
  ↳ CR

mainModule FiniteMap
  ((elemFM :: ()  ->  FiniteMap () a  ->  Bool) :: ()  ->  FiniteMap () a  ->  Bool)

module FiniteMap where
  import qualified Maybe
import qualified Prelude

  data FiniteMap b a = EmptyFM  | Branch b a Int (FiniteMap b a) (FiniteMap b a


  instance (Eq a, Eq b) => Eq (FiniteMap a b) where 

  elemFM :: Ord a => a  ->  FiniteMap a b  ->  Bool
elemFM key fm 
case lookupFM fm key of
  Nothing-> False
  Just elt-> True

  lookupFM :: Ord a => FiniteMap a b  ->  a  ->  Maybe b
lookupFM EmptyFM key Nothing
lookupFM (Branch key elt _ fm_l fm_rkey_to_find 
 | key_to_find < key = 
lookupFM fm_l key_to_find
 | key_to_find > key = 
lookupFM fm_r key_to_find
 | otherwise = 
Just elt


module Maybe where
  import qualified FiniteMap
import qualified Prelude



Case Reductions:
The following Case expression
case lookupFM fm key of
 Nothing → False
 Just elt → True

is transformed to
elemFM0 Nothing = False
elemFM0 (Just elt) = True



↳ HASKELL
  ↳ CR
HASKELL
      ↳ BR

mainModule FiniteMap
  ((elemFM :: ()  ->  FiniteMap () a  ->  Bool) :: ()  ->  FiniteMap () a  ->  Bool)

module FiniteMap where
  import qualified Maybe
import qualified Prelude

  data FiniteMap b a = EmptyFM  | Branch b a Int (FiniteMap b a) (FiniteMap b a


  instance (Eq a, Eq b) => Eq (FiniteMap a b) where 

  elemFM :: Ord b => b  ->  FiniteMap b a  ->  Bool
elemFM key fm elemFM0 (lookupFM fm key)

  
elemFM0 Nothing False
elemFM0 (Just eltTrue

  lookupFM :: Ord b => FiniteMap b a  ->  b  ->  Maybe a
lookupFM EmptyFM key Nothing
lookupFM (Branch key elt _ fm_l fm_rkey_to_find 
 | key_to_find < key = 
lookupFM fm_l key_to_find
 | key_to_find > key = 
lookupFM fm_r key_to_find
 | otherwise = 
Just elt


module Maybe where
  import qualified FiniteMap
import qualified Prelude



Replaced joker patterns by fresh variables and removed binding patterns.

↳ HASKELL
  ↳ CR
    ↳ HASKELL
      ↳ BR
HASKELL
          ↳ COR

mainModule FiniteMap
  ((elemFM :: ()  ->  FiniteMap () a  ->  Bool) :: ()  ->  FiniteMap () a  ->  Bool)

module FiniteMap where
  import qualified Maybe
import qualified Prelude

  data FiniteMap a b = EmptyFM  | Branch a b Int (FiniteMap a b) (FiniteMap a b


  instance (Eq a, Eq b) => Eq (FiniteMap a b) where 

  elemFM :: Ord a => a  ->  FiniteMap a b  ->  Bool
elemFM key fm elemFM0 (lookupFM fm key)

  
elemFM0 Nothing False
elemFM0 (Just eltTrue

  lookupFM :: Ord a => FiniteMap a b  ->  a  ->  Maybe b
lookupFM EmptyFM key Nothing
lookupFM (Branch key elt vw fm_l fm_rkey_to_find 
 | key_to_find < key = 
lookupFM fm_l key_to_find
 | key_to_find > key = 
lookupFM fm_r key_to_find
 | otherwise = 
Just elt


module Maybe where
  import qualified FiniteMap
import qualified Prelude



Cond Reductions:
The following Function with conditions
lookupFM EmptyFM key = Nothing
lookupFM (Branch key elt vw fm_l fm_rkey_to_find
 | key_to_find < key
 = lookupFM fm_l key_to_find
 | key_to_find > key
 = lookupFM fm_r key_to_find
 | otherwise
 = Just elt

is transformed to
lookupFM EmptyFM key = lookupFM4 EmptyFM key
lookupFM (Branch key elt vw fm_l fm_rkey_to_find = lookupFM3 (Branch key elt vw fm_l fm_rkey_to_find

lookupFM1 key elt vw fm_l fm_r key_to_find True = lookupFM fm_r key_to_find
lookupFM1 key elt vw fm_l fm_r key_to_find False = lookupFM0 key elt vw fm_l fm_r key_to_find otherwise

lookupFM0 key elt vw fm_l fm_r key_to_find True = Just elt

lookupFM2 key elt vw fm_l fm_r key_to_find True = lookupFM fm_l key_to_find
lookupFM2 key elt vw fm_l fm_r key_to_find False = lookupFM1 key elt vw fm_l fm_r key_to_find (key_to_find > key)

lookupFM3 (Branch key elt vw fm_l fm_rkey_to_find = lookupFM2 key elt vw fm_l fm_r key_to_find (key_to_find < key)

lookupFM4 EmptyFM key = Nothing
lookupFM4 wv ww = lookupFM3 wv ww

The following Function with conditions
undefined 
 | False
 = undefined

is transformed to
undefined  = undefined1

undefined0 True = undefined

undefined1  = undefined0 False



↳ HASKELL
  ↳ CR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
HASKELL
              ↳ Narrow

mainModule FiniteMap
  (elemFM :: ()  ->  FiniteMap () a  ->  Bool)

module FiniteMap where
  import qualified Maybe
import qualified Prelude

  data FiniteMap a b = EmptyFM  | Branch a b Int (FiniteMap a b) (FiniteMap a b


  instance (Eq a, Eq b) => Eq (FiniteMap b a) where 

  elemFM :: Ord b => b  ->  FiniteMap b a  ->  Bool
elemFM key fm elemFM0 (lookupFM fm key)

  
elemFM0 Nothing False
elemFM0 (Just eltTrue

  lookupFM :: Ord a => FiniteMap a b  ->  a  ->  Maybe b
lookupFM EmptyFM key lookupFM4 EmptyFM key
lookupFM (Branch key elt vw fm_l fm_rkey_to_find lookupFM3 (Branch key elt vw fm_l fm_r) key_to_find

  
lookupFM0 key elt vw fm_l fm_r key_to_find True Just elt

  
lookupFM1 key elt vw fm_l fm_r key_to_find True lookupFM fm_r key_to_find
lookupFM1 key elt vw fm_l fm_r key_to_find False lookupFM0 key elt vw fm_l fm_r key_to_find otherwise

  
lookupFM2 key elt vw fm_l fm_r key_to_find True lookupFM fm_l key_to_find
lookupFM2 key elt vw fm_l fm_r key_to_find False lookupFM1 key elt vw fm_l fm_r key_to_find (key_to_find > key)

  
lookupFM3 (Branch key elt vw fm_l fm_rkey_to_find lookupFM2 key elt vw fm_l fm_r key_to_find (key_to_find < key)

  
lookupFM4 EmptyFM key Nothing
lookupFM4 wv ww lookupFM3 wv ww


module Maybe where
  import qualified FiniteMap
import qualified Prelude



Haskell To QDPs